// 内容管理系统后台仪表盘系统
class DashboardManager {
    constructor() {
        // 不在构造函数中调用init()，避免初始化冲突
    }

    // 初始化系统
    init() {
        this.setupEventListeners();
        this.startRealTimeUpdates();
        this.loadDashboardData();
        this.updateAlerts();
    }

    // 设置事件监听器
    setupEventListeners() {
        // 内容管理系统事件监听器
    }

    // 开始实时更新
    startRealTimeUpdates() {
        // 更新时间显示
        this.updateTimeDisplay();
        setInterval(() => this.updateTimeDisplay(), 1000);

        // 实时数据更新（每30秒）
        setInterval(() => this.updateRealTimeData(), 30000);

        // 预警检查（每5分钟）
        setInterval(() => this.updateAlerts(), 300000);
    }

    // 更新时间显示
    updateTimeDisplay() {
        const now = new Date();
        const timeString = now.toLocaleTimeString('zh-CN');
        const timeElement = document.getElementById('currentTime');
        if (timeElement) {
            timeElement.textContent = timeString;
        }
        
        // 显示多时区时间
        this.displayMultipleTimeZones();
    }

    // 显示多时区时间
    displayMultipleTimeZones() {
        const timeZones = [
            { name: '纽约', offset: -5 },
            { name: '伦敦', offset: 0 },
            { name: '东京', offset: 9 },
            { name: '悉尼', offset: 10 }
        ];

        // 这里可以扩展显示其他时区时间
    }

    // 加载仪表盘数据
    async loadDashboardData() {
        try {
            const data = await this.fetchDashboardData();
            
            // 直接更新数据
            this.updateMetricsDisplay(data.metrics);
            this.updateAlerts(data.alerts);
            
        } catch (error) {
            console.error('加载仪表盘数据失败:', error);
            this.showError('数据加载失败，请检查网络连接');
        }
    }

    // 获取仪表盘数据
    async fetchDashboardData() {
        try {
            const response = await fetch('/api/dashboard/metrics', {
                method: 'GET',
                headers: {
                    'Content-Type': 'application/json',
                    'Authorization': `Bearer ${localStorage.getItem('authToken') || ''}`
                }
            });
            
            if (!response.ok) {
                throw new Error(`HTTP错误! 状态码: ${response.status}`);
            }
            
            const result = await response.json();
            
            if (result.success) {
                return result.data;
            } else {
                throw new Error(result.message || '获取数据失败');
            }
        } catch (error) {
            console.error('获取仪表盘数据失败:', error);
            throw new Error('无法连接到仪表盘数据服务，请检查网络连接');
        }
    }

    // 更新指标显示（简化版）
    updateMetricsDisplay(metrics) {
        // 访客数据指标
        document.getElementById('todayVisitors').textContent = metrics.todayVisitors.toLocaleString();
        this.updateChangeIndicator('visitorsChange', metrics.visitorsChange);

        // 页面浏览量指标
        document.getElementById('pageViews').textContent = metrics.pageViews.toLocaleString();
        this.updateChangeIndicator('pageViewsChange', metrics.pageViewsChange);

        // 留言数据指标
        document.getElementById('newMessages').textContent = metrics.newMessages.toLocaleString();
        this.updateChangeIndicator('messagesChange', metrics.messagesChange);

        // 邮件订阅指标
        document.getElementById('emailSubscribers').textContent = metrics.emailSubscribers.toLocaleString();
        this.updateChangeIndicator('subscribersChange', metrics.subscribersChange);

        // 博客数据指标
        document.getElementById('blogArticles').textContent = metrics.blogArticles.toLocaleString();
        this.updateChangeIndicator('articlesChange', metrics.articlesChange);

        // 博客阅读量指标
        document.getElementById('blogReads').textContent = metrics.blogReads.toLocaleString();
        this.updateChangeIndicator('readsChange', metrics.readsChange);
        this.updateChangeIndicator('abandonedChange', metrics.abandonedChange);

        // 高亮异常指标
        this.highlightAbnormalMetrics(metrics);
    }

    // 更新变化指示器
    updateChangeIndicator(elementId, change) {
        const element = document.getElementById(elementId);
        const changeValue = parseFloat(change);
        
        element.className = 'metric-change';
        element.innerHTML = '';
        
        if (changeValue > 0) {
            element.classList.add('positive');
            element.innerHTML = `<i class="fas fa-arrow-up"></i> ${Math.abs(changeValue)}%`;
        } else if (changeValue < 0) {
            element.classList.add('negative');
            element.innerHTML = `<i class="fas fa-arrow-down"></i> ${Math.abs(changeValue)}%`;
        } else {
            element.innerHTML = `<i class="fas fa-minus"></i> 0%`;
        }
    }

    // 高亮异常指标
    highlightAbnormalMetrics(metrics) {
        // 内容管理系统异常检测逻辑...
    }





    // 更新预警信息
    updateAlerts(alerts = null) {
        const container = document.getElementById('alertsContainer');
        
        // 如果容器不存在，则不执行更新
        if (!container) {
            console.warn('alertsContainer元素不存在，跳过预警更新');
            return;
        }
        
        if (!alerts) {
            alerts = [];
        }
        
        container.innerHTML = '';
        
        alerts.forEach(alert => {
            const alertElement = document.createElement('div');
            alertElement.className = `alert-item ${alert.type}`;
            
            alertElement.innerHTML = `
                <div class="alert-icon">
                    <i class="fas ${this.getAlertIcon(alert.type)}"></i>
                </div>
                <div class="alert-content">
                    <div class="alert-title">${alert.title}</div>
                    <div class="alert-desc">${alert.description}</div>
                </div>
            `;
            
            container.appendChild(alertElement);
        });
    }



    // 获取预警图标
    getAlertIcon(type) {
        const icons = {
            'warning': 'exclamation-triangle',
            'info': 'info-circle',
            'error': 'exclamation-circle'
        };
        return icons[type] || 'info-circle';
    }

    // 实时数据更新
    async updateRealTimeData() {
        try {
            const realTimeData = await this.fetchRealTimeData();
            this.updateRealTimeMetrics(realTimeData);
        } catch (error) {
            console.error('实时数据更新失败:', error);
        }
    }

    // 获取实时数据
    async fetchRealTimeData() {
        try {
            const response = await fetch('/api/dashboard/realtime', {
                method: 'GET',
                headers: {
                    'Content-Type': 'application/json',
                    'Authorization': `Bearer ${localStorage.getItem('authToken') || ''}`
                }
            });
            
            if (!response.ok) {
                throw new Error(`HTTP错误! 状态码: ${response.status}`);
            }
            
            const result = await response.json();
            
            if (result.success) {
                return result.data;
            } else {
                throw new Error(result.message || '获取实时数据失败');
            }
        } catch (error) {
            console.error('获取实时数据失败:', error);
            return { newOrders: 0, revenueIncrease: 0 };
        }
    }

    // 更新实时指标
    updateRealTimeMetrics(data) {
        // 这里可以实现实时数据的动画效果更新
        console.log('实时数据更新:', data);
    }

    // 显示错误消息
    showError(message) {
        this.showMessage(message, 'error');
    }

    // 显示消息提示
    showMessage(message, type = 'success') {
        const alert = document.createElement('div');
        alert.style.cssText = `
            position: fixed;
            top: 20px;
            right: 20px;
            padding: 15px 20px;
            border-radius: 4px;
            color: white;
            z-index: 10000;
            font-weight: bold;
            background: ${type === 'success' ? '#27ae60' : '#e74c3c'};
        `;
        alert.textContent = message;
        
        document.body.appendChild(alert);
        
        setTimeout(() => {
            document.body.removeChild(alert);
        }, 3000);
    }
}



// 初始化仪表盘系统
function initializeDashboard() {
    if (window.dataManager) {
        try {
            window.dashboardManager = new DashboardManager();
            console.log('仪表盘系统初始化成功');
            
            // 确保货币选择器正确设置
            setTimeout(() => {
                if (window.dashboardManager) {
                    window.dashboardManager.setInitialCurrency();
                    window.dashboardManager.updateAllCurrencyDisplays();
                }
            }, 100);
        } catch (error) {
            console.error('仪表盘系统初始化失败:', error);
            alert('系统初始化失败，请刷新页面重试');
        }
    } else {
        // 如果dataManager不存在，等待它初始化
        const waitForDataManager = setInterval(() => {
            if (window.dataManager) {
                clearInterval(waitForDataManager);
                try {
                    window.dashboardManager = new DashboardManager();
                    console.log('仪表盘系统初始化成功');
                    
                    // 确保货币选择器正确设置
                    setTimeout(() => {
                        if (window.dashboardManager) {
                            window.dashboardManager.setInitialCurrency();
                            window.dashboardManager.updateAllCurrencyDisplays();
                        }
                    }, 100);
                } catch (error) {
                    console.error('仪表盘系统初始化失败:', error);
                    alert('系统初始化失败，请刷新页面重试');
                }
            }
        }, 100);
        
        // 设置超时（5秒后放弃等待）
        setTimeout(() => {
            clearInterval(waitForDataManager);
            if (!window.dataManager) {
                console.error('数据管理器初始化超时，无法启动仪表盘系统');
                alert('系统初始化失败，请刷新页面重试');
            }
        }, 5000);
    }
}

// 页面加载完成后初始化
document.addEventListener('DOMContentLoaded', function() {
    // 创建全局仪表盘管理器实例
    if (!window.dashboardManager) {
        window.dashboardManager = new DashboardManager();
        console.log('仪表盘管理器已创建');
    }
    
    initializeDashboard();
});